// <copyright file="MusicalOrchestration.cs" company="Largo">
// Copyright (c) 2009 All Right Reserved
// </copyright>
// <author> vl </author>
// <email></email>
// <date>2009-01-01</date>
// <summary>Contains ...</summary>

namespace LargoCommon.Music
{
    using Abstract;
    using JetBrains.Annotations;
    using System;
    using System.Collections.Generic;
    using System.IO;
    using System.IO.Compression;
    using System.Linq;
    using System.Text;
    using System.Xml.Linq;

    /// <summary>
    /// Harmonic Streams Port.
    /// </summary>
    public class MusicalOrchestration
    {
        #region Constructors

        /// <summary>
        /// Initializes a new instance of the <see cref="MusicalOrchestration" /> class.
        /// </summary>
        public MusicalOrchestration() {
            this.OrchestraBlocks = new List<OrchestraBlock>();
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="MusicalOrchestration"/> class.
        /// </summary>
        /// <param name="givenBlock">The given block.</param>
        public MusicalOrchestration(MusicalBlock givenBlock) {
            this.ObjectName = givenBlock.FullName;
            this.Header = givenBlock.Header;
            this.OrchestraBlocks = new List<OrchestraBlock>();

            var body = givenBlock.Body;
            //// ?!?!?! body.SetHarmonicBasis(this.BlockChanges); //// true
            var simpleChanges = body.ExtractSimpleChanges(MusicalChangeType.Instrument);
            //// var simpleChanges = this.BlockChanges.InstrumentChanges;
            var changedBarNumbers = (from ic in simpleChanges select ic.BarNumber).Distinct().ToList();
            OrchestraBlock lastOrchestraBlock = null;
            var changedBars = from b in body.Bars where changedBarNumbers.Contains(b.BarNumber) select b;

            foreach (var bar in changedBars) {
                if (lastOrchestraBlock != null) {
                    lastOrchestraBlock.BarNumberTo = bar.BarNumber - 1;
                }

                var strip = bar.OrchestraStrip();
                var orchestraBlock = new OrchestraBlock(givenBlock.Header, bar.BarNumber, strip);
                this.OrchestraBlocks.Add(orchestraBlock);
                lastOrchestraBlock = orchestraBlock;
            }

            if (lastOrchestraBlock != null) {
                lastOrchestraBlock.BarNumberTo = givenBlock.Header.NumberOfBars;
            }
        }
        #endregion

        #region Public properties
        /// <summary>
        /// Gets or sets the header.
        /// </summary>
        /// <value>
        /// The header.
        /// </value>
        public MusicalHeader Header { get; set; }

        /// <summary>
        /// Gets or sets the name of the style.
        /// </summary>
        /// <value>
        /// The name of the set.
        /// </value>
        public string ObjectName { get; set; }

        /// <summary>
        /// Gets a value indicating whether is valid.
        /// </summary>
        /// <value>
        ///   <c>true</c> if this instance is valid; otherwise, <c>false</c>.
        /// </value>
        [UsedImplicitly]
        public bool IsValid => this.OrchestraBlocks.Any();

        /// <summary>
        /// Gets or sets the instrumentation of bars.
        /// </summary>
        /// <value>
        /// Property description.
        /// </value>
        public IList<OrchestraBlock> OrchestraBlocks { get; set; }

        #endregion

        #region Public static factory methods

        #endregion

        /// <summary>
        /// Orchestrates the specified given block.
        /// </summary>
        /// <param name="givenBlock">The given block.</param>
        /// <param name="area">The area.</param>
        /// <param name="orchestraBlock">The orchestra block.</param>
        public static void Orchestrate(MusicalBlock givenBlock, MusicalSection area, OrchestraBlock orchestraBlock) {
            int line = -1;
            foreach (var mtrack in givenBlock.Strip.Lines) {
                line++;
                if (mtrack == null) {
                    continue;
                }

                var track = orchestraBlock.Strip.OptimalOrchestraTrack(mtrack);
                if (track == null) {
                    continue;
                }

                if (mtrack.FirstStatus != null) {
                    mtrack.FirstStatus.CurrentOrchestraTrack = track;
                }

                if (mtrack.FirstStatus != null) {
                    mtrack.FirstStatus.Instrument = track.Instrument;
                }

                var tones = mtrack.MusicalTonesInArea(area);
                tones.SetInstrument(track.InstrumentNumber, track.Octave);

                for (var bar = 1; bar <= givenBlock.Header.NumberOfBars; bar++) {
                    var point = MusicalPoint.GetPoint(line, bar);  //// 2017/03 !?!?
                    //// var point = MusicalPoint.GetPoint(mtrack.LineIndex, bar); //// line
                    var me = givenBlock.Body.GetElement(point);
                    if (me == null) {
                        continue;
                    }

                    me.Status.Instrument = track.Instrument;
                }

                track.IsUsed = true;
            }
        }

        #region String representation
        /// <summary> String representation of the object. </summary>
        /// <returns> Returns value. </returns>
        public override string ToString() {
            var s = new StringBuilder();
            s.AppendFormat("Orchestra {0}", this.ObjectName);

            return s.ToString();
        }
        #endregion

        #region Public methods
        /// <summary>
        /// Adds the content of the style.
        /// </summary>
        /// <param name="orchestration">The orchestration.</param>
        [UsedImplicitly]
        public void AddObjectContent(MusicalOrchestration orchestration) {
            //// this = style.HarmonicOrder; this.RhythmicOrder = style.RhythmicOrder; //// ??????? 
            var ob = (List<OrchestraBlock>)this.OrchestraBlocks;
            ob.AddRange(orchestration.OrchestraBlocks);
        }

        /// <summary>
        /// Saves the style.
        /// </summary>
        /// <param name="givenFolder">The given folder.</param>
        [UsedImplicitly]
        public void SaveToFolder(string givenFolder) {
            var tmpFolderPath = SupportFiles.GetTemporaryDirectory;
            Directory.CreateDirectory(tmpFolderPath);
            XElement xcomponent = new XElement(
                "Component",
                new XAttribute("Description", string.Empty),
                new XAttribute("Name", this.ObjectName), 
                this.Header.GetXElement);

            var xdoc = new XDocument(new XDeclaration("1.0", "utf-8", null), xcomponent);
            xdoc.Save(Path.Combine(tmpFolderPath, @"Component.xml"));

            //// Orchestra Blocks
            var xblocks = this.WriteOrchestraBlocks();
            xdoc = new XDocument(new XDeclaration("1.0", "utf-8", null), xblocks);
            //// var filepath = Path.Combine(givenPath, "RhythmicPatterns.xml");
            xdoc.Save(Path.Combine(tmpFolderPath, @"OrchestraBlocks.xml"));

            var finalPath = Path.Combine(givenFolder, this.ObjectName.ClearSpecialChars() + ".orchestra");
            ZipFile.CreateFromDirectory(tmpFolderPath, finalPath);
            //// ZipFileCover.CreateZipFileRecursive(tmpFolderPath, finalPath, false, true);
            Directory.Delete(tmpFolderPath, true);
        }

        #endregion

        #region Public methods - Orchestration
        /// <summary>
        /// Gets the orchestra block for.
        /// </summary>
        /// <param name="numberOfMelodicTracks">The number of melodic tracks.</param>
        /// <param name="numberOfRhythmicTracks">The number of rhythmic tracks.</param>
        /// <param name="previousBlock">Orchestra block.</param>
        /// <returns>
        /// Returns value.
        /// </returns>
        public OrchestraBlock GetOrchestraBlockFor(byte numberOfMelodicTracks, byte numberOfRhythmicTracks, OrchestraBlock previousBlock) {
            var trackCount = numberOfMelodicTracks + numberOfRhythmicTracks;
            var blockCount = this.OrchestraBlocks.Count;
            if (blockCount == 0) {
                return null;
            }

            OrchestraBlock optimalBlock = null;
            var maxvalue = 0;
            foreach (var block in this.OrchestraBlocks) {
                var value = 100 - Math.Abs(block.TrackCount - trackCount);
                if (block.TrackCount < trackCount) {
                    value -= 20;
                }

                if (previousBlock != null && block.Name == previousBlock.Name) {
                    value -= 10;
                }

                value += MathSupport.RandomNatural(10);

                if (value > maxvalue) {
                    maxvalue = value;
                    optimalBlock = block;
                }
            }

            return optimalBlock;
            ////var idx = MathSupport.RandomNatural(blockCount);
            //// return this.OrchestraBlocks[idx];
        }

        /// <summary>
        /// Gets the orchestra block for - in simple (one block) styles.
        /// </summary>
        /// <param name="givenBarNumber">The given bar number.</param>
        /// <returns> Returns value. </returns>
        [UsedImplicitly]
        public OrchestraBlock GetOrchestraBlockFor(int givenBarNumber) {
            if (!this.OrchestraBlocks.Any()) {
                return null;
            }

            var orchestraBlock = (from ob in this.OrchestraBlocks
                                  where ob.BarNumberFrom <= givenBarNumber && ob.BarNumberTo >= givenBarNumber
                                  select ob).FirstOrDefault();
            return orchestraBlock;
        }

        /// <summary>
        /// Orchestrates the musical block.
        /// </summary>
        /// <param name="givenBlock">The given block.</param>
        public void OrchestrateMusicalBlock(MusicalBlock givenBlock) {
            OrchestraBlock lastOBlock = null;
            //// Cycle through current orchestra blocks
            var orchestration = new MusicalOrchestration(givenBlock); 

            foreach (var block in orchestration.OrchestraBlocks) {
                if (block == null) {
                    continue;
                }

                var area = new MusicalSection(block.BarNumberFrom, block.BarNumberTo, string.Empty);
                //// this.blockEditor.NumberOfLines
                byte numberOfMelodicLines = (byte)givenBlock.Strip.Lines.Count;  ////  this.NumberOfUsedLines(area);
#warning numberOfRhythmicLines
                byte numberOfRhythmicLines = 0;                             ////  this.NumberOfUsedLines(area);

                //// To get ne orchestra block for the substitution 
                var orchestraBlock = this.GetOrchestraBlockFor(numberOfMelodicLines, numberOfRhythmicLines, lastOBlock);
                lastOBlock = orchestraBlock;
                if (orchestraBlock == null) {
                    return;
                }

                Orchestrate(givenBlock, area, orchestraBlock);
            }
        }

        #endregion

        #region Private static methods
        /// <summary>
        /// Initializes a new instance of the <see cref="MusicalStyle" /> class.
        /// </summary>
        /// <param name="givenFilePath">The given file path.</param>
        /// <returns>Returns value.</returns>
        [UsedImplicitly]
        private static MusicalOrchestration GetOrchestration(string givenFilePath) {
            var style = new MusicalOrchestration();
            var fileName = Path.GetFileNameWithoutExtension(givenFilePath);
            if (fileName == null) {
                return null;
            }

            style.ObjectName = fileName.Trim();

            var tmpFolderPath = MusicalSettings.Singleton.Folders.GetTemporaryFolder; //// SupportFiles.GetTemporaryDirectory;
            if (tmpFolderPath == null) {
                return null;
            }

            ZipFile.ExtractToDirectory(givenFilePath, tmpFolderPath);
            //// ZipFileCover.UnzipFile(givenFilePath, tmpFolderPath);

            var fi = SupportFiles.LatestFile(tmpFolderPath, "*.xml");
            if (fi == null) {
                if (Directory.Exists(tmpFolderPath)) {
                    Directory.Delete(tmpFolderPath, true);
                }

                return null;
            }

            var root = XmlSupport.GetXDocRoot(Path.Combine(tmpFolderPath, "Component.xml"));
            if (root != null && root.Name == "Component") {
                var xstyle = root;
                //// var description = XmlSupport.ReadStringAttribute(xstyle.Attribute("Description"));
                //// unused var name = XmlSupport.ReadStringAttribute(xstyle.Attribute("Name"));
                style.Header = new MusicalHeader(xstyle.Element("Header"));
                //// this.HarmonicOrder = XmlSupport.ReadByteAttribute(xstyle.Attribute("HarmonicOrder"));
                //// this.RhythmicOrder = XmlSupport.ReadByteAttribute(xstyle.Attribute("RhythmicOrder"));
            }

            style.LoadOrchestraBlocks(Path.Combine(tmpFolderPath, "OrchestraBlocks.xml"));
            //// MusicalStyle.internalSingleton = this;

            if (Directory.Exists(tmpFolderPath)) {
                Directory.Delete(tmpFolderPath, true);
            }

            return style;
        }
        #endregion

        #region Private methods - Load finals

        /// <summary>
        /// Loads the orchestra model.
        /// </summary>
        /// <param name="filePath">The file path.</param>
        private void LoadOrchestraBlocks(string filePath) {
            var root = XmlSupport.GetXDocRoot(filePath);
            if (root != null && root.Name == "OrchestraBlocks") {
                var xbundle = root;
                var xblocks = xbundle.Elements("Block");

                var list = new List<OrchestraBlock>();
                // ReSharper disable once LoopCanBeConvertedToQuery
                foreach (var xblock in xblocks) {
                    var orchestraBlock = new OrchestraBlock(xblock);
                    list.Add(orchestraBlock);
                }

                this.OrchestraBlocks = list;
            }
        }

        #endregion

        #region Private methods - Save final

        /// <summary>
        /// Writes the orchestra blocks.
        /// </summary>
        /// <returns>Returns value.</returns>
        private XElement WriteOrchestraBlocks() {
            XElement xblocks = new XElement(
                "OrchestraBlocks",
                new XAttribute("Description", string.Empty));

            foreach (var orchestraBlock in this.OrchestraBlocks) {
                XElement xblock = orchestraBlock.GetXElement;
                xblocks.Add(xblock);
            }

            return xblocks;
        }

        #endregion
    }
}